export function dateFormat(DateStr?:string|number){//定义方法 接收时间的字符串
    DateStr = DateStr||Date.now()
    const dt=new Date(DateStr);
    const y=dt.getFullYear();//年 月
 
    const m=padZero(dt.getMonth()+1);//getMonth输出的是0-11的月份，对应的要进行相加
    const d=padZero(dt.getDate());//
    const h=padZero(dt.getHours());
    const min=padZero(dt.getMinutes());
    const s=padZero(dt.getSeconds());
 
 
    // return `${y}-${m}-${d} ${h}:${min}:${s}`
    return `${y}-${m}-${d}_${h}-${min}-${s}`
 
}
//定义补零的函数
function padZero(n:number){//接收数字n
  return  n>9 ? n : '0'+ n;//时间=1-01 
}
 


// 示例用法
// const inputArray = ["apple", "banana", "cherry", "applepie", "applesauce"];
// const result = findMostFrequentSubstring(inputArray);
// console.log(result); // 输出：{ substring: "apple", frequency: 3 }
/**
 * 该函数用于查找一个字符串数组中出现次数最多的子字符串及其频率。
 * 函数遍历数组中的每个字符串，然后通过嵌套循环对每个字符串进行切分，
 * 得到所有子字符串，并使用 Map 对象记录每个子字符串出现的次数。
 * 在遍历过程中，函数维护一个最大频率和最频繁子字符串的变量，当发现出现次数更多的子字符串时进行更新。
 * 最终返回最频繁子字符串及其频率的对象，如果数组为空则返回 undefined。
 * @param arr 
 * @returns 
 */

class SubstringFrequency {
  substring: string;
  frequency: number;
}
export function findTopThreeFrequentSubstrings(
  targetArray: string[],
  minLength: number,
  blacklist: string[]
): SubstringFrequency[] {
  if (!targetArray.length) return [];

  const substringMap = new Map<string, number>();
  const result: SubstringFrequency[] = [];

  for (const str of targetArray) {
    for (let j = 0; j <= str.length - minLength; j++) {
      for (let k = minLength; k <= str.length - j; k++) {
        const substring = str.substr(j, k);

        // 检查子字符串是否包含黑名单中的任何成员
        const containsBlacklistedSubstring = blacklist.some(blacklisted => 
          substring.includes(blacklisted)
        );
        
        if (containsBlacklistedSubstring) continue;

        substringMap.set(substring, (substringMap.get(substring) ?? 0) + 1);
      }
    }
  }

  // 获取出现次数最多的前三个子字符串
  const sortedFrequencies = Array.from(substringMap.entries())
    .sort(([, freqA], [, freqB]) => freqB - freqA)
    .slice(0, 3)
    .map(([substring, frequency]) => ({ substring, frequency }));

  return sortedFrequencies;
}